package cn.krund.lyc.hotlerobot.utils;

/**
 * @包名: cn.krund.lyc.hotlerobot.utils
 * @作者: 刘育成
 * @时间: 2018/4/5  15:14
 * @org: 克路德人工智能
 * @描述: TODO  数据转换
 * @fileName: DataConversionUtil
 */

public class DataConversionUtil {
    /**
     * byte转float
     * @param b         需要转换的byte数组
     * @param index     需要转换的起始位
     * @return
     */
    public static float byte2Float(byte[] b, int index) {
        int l;
        l = b[index + 0];
        l &= 0xff;
        l |= ((long) b[index + 1] << 8);
        l &= 0xffff;
        l |= ((long) b[index + 2] << 16);
        l &= 0xffffff;
        l |= ((long) b[index + 3] << 24);
        return Float.intBitsToFloat(l);
    }

    /**
     * int转byte数组
     * @param n
     * @return
     */
    public static byte[] int2Bytes(int n) {
        byte[] b = new byte[4];
        for (int i = 0; i < 4; i++) {
            b[i] = (byte) (n >> (24 - i * 8));
        }
        return b;
    }

    /**
     * Byte转float()     Byte是包装类型，型默认是null
     * @param b         需要转换的Byte数组
     * @param index     需要转换的起始位
     * @return
     */
    public static int byte2Int(Byte[] b, int index) {
        int value= 0;
        for (int i = 0; i < 4; i++) {
            int shift= (4 - 1 - i) * 8;
            value +=(b[i + index] & 0x000000FF) << shift;//往高位游
        }
        return value;
    }

    /**
     * byte转float      byte是基本类型
     * @param b         需要转换的byte数组
     * @param index     需要转换的起始位
     * @return
     */
    public static int byte2Int(byte[] b, int index) {
        int value= 0;
        for (int i = 0; i < 4; i++) {
            int shift= (4 - 1 - i) * 8;
            value +=(b[i + index] & 0x000000FF) << shift;//往高位游
        }
        return value;
    }

    /**
     * 适用于数据位在高位的
     * @param b          byte数组
     * @return           int 数据
     */
    public static int byte2Int(byte[] b){
        int value = 0;
        byte bLoop;
        for(int i=0;i<b.length;i++){
            bLoop = b[i];
            value +=(bLoop & 0xFF) << (8*i);
        }
        return value;
    }
    //高位在前，低位在后
    public static int bytes2int(byte[] bytes){
        int result = 0;
        if(bytes.length == 4){
            int a = (bytes[0] & 0xff) << 24;//说明二
            int b = (bytes[1] & 0xff) << 16;
            int c = (bytes[2] & 0xff) << 8;
            int d = (bytes[3] & 0xff);
            result = a | b | c | d;
        }
        return result;
    }
    /**
     * float转byte数组
     * @param f
     * @return
     */
    public static byte[] float2byte(float f) {
        int fbit = Float.floatToIntBits(f);             // 把float转换为byte[]

        byte[] b = new byte[4];
        for (int i = 0; i < 4; i++) {
            b[i] = (byte) (fbit >> (24 - i * 8));
        }

        int len = b.length;                             // 翻转数组
        byte[] dest = new byte[len];                    // 建立一个与源数组元素类型相同的数组
        System.arraycopy(b, 0, dest, 0, len);           // 为了防止修改源数组，将源数组拷贝一份副本
        byte temp;
        // 将顺位第i个与倒数第i个交换
        for (int i = 0; i < len / 2; ++i) {
            temp = dest[i];
            dest[i] = dest[len - i - 1];
            dest[len - i - 1] = temp;
        }

        return dest;
    }

    /**
     * 数组反转
     * @param bs
     * @return
     */
    public static byte[] reverse(byte[] bs){
        byte[] ret = new byte[bs.length];
        for(int i=0;i<bs.length;i++){
            ret[i]=bs[bs.length-i-1];
        }

        return ret;
    }

    /**
     * byte 转 String
     * @param src byte数据
     * @return
     */
    public static String bytes2HexString(byte[] src){
        StringBuilder stringBuilder = new StringBuilder("");
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }

    //byte[]转16进制字符串
    public static final String bytesToHexString(byte[] bArray) {
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2)
                sb.append(0);
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 字节数组转为普通字符串（ASCII对应的字符）
     *
     * @param bytearray
     *            byte[]
     * @return String
     */
    public static String bytetoString(byte[] bytearray) {
        String result = "";
        char temp;

        int length = bytearray.length;
        for (int i = 0; i < length; i++) {
            temp = (char) bytearray[i];
            result += temp;
        }
        return result;
    }


}

